// 导入express框架
const express = require('express')
// 创建路由
const router = express.Router()
// const bcrypt = require('bcryptjs')
// 导入数据文件
// const db = require('../../config/db')
// 导入用户数据模块
const userModel = require('../../model/userModel')
// 引入jwt token工具
const JwtUtil = require('../../utils/jwt')
const getCreateTime = require('../../utils/getCreateTime')
// 引入全局文件
const config = require('../../config/default')
// 记录服务器地址
const HOSTURL = `${config.PROTOCOL}://${config.HOST}:${config.PORT}`
// 导入上传图片的模块
let multer = require('multer')
// 导入读写文件的模块
// let fs = require('fs')
// 生成ID
const { v4: uuidv4 } = require('uuid')

// 正则表达式
const rep_phone = /^1[3-9]\d{9}$/
const rep_email = /^([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|\_|\.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,3}$/

// 1.0 注册接口
// 参数：user_name , user_password, user_email
// router.post('/register', async (req, res) => {
//     let user_id = uuidv4() || Math.random().toString().slice(2);//随机ID
//     let user_name = req.body.user_name; // 用户名
//     let user_password = req.body.user_password; // 密码
//     let user_email = req.body.user_email; //  邮箱 
//     let user_create_time = req.body.user_create_time || getCreateTime.now()//  用户创建的时间 （'2022-09-29 00:00:00'）
//     // 调用注册方法
//     await userModel.register(user_id, user_name, user_password, user_email, user_create_time)// 无邮箱验证码
//         .then(
//             data => {
//                 res.send(data)
//             }
//         )
//         .catch(
//             err => {
//                 res.send({ code: 500, msg: '服务器异常...', err })
//             }
//         )
// })
// 注册接口 (有验证码)
router.post('/add', async (req, res) => {
    let user_id = uuidv4() || Math.random().toString().slice(2);//随机ID
    let user_name = req.body.user_name; // 用户名
    let user_password = req.body.user_password; // 密码
    let user_email = req.body.user_email; //  邮箱 
    let user_create_time = req.body.user_create_time || getCreateTime.now()//  用户创建的时间 （'2022-09-29 00:00:00'）
    let code = req.body.code //验证码
    // console.log({user_name , user_password, user_email,code})
      // 判断前端是否传值
      if(user_name == undefined || user_password == undefined || user_email == undefined || code == undefined ){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确111?'
        })
        return ;
    }

    if(user_name == false || user_password == false || user_email == false || code == false ){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确222?'
        })
        return ;
    }

    if(rep_email.test(user_email)) {
        // 调用注册方法
        await userModel.addUser(user_id, user_name, user_password, user_email, user_create_time, code)// 有邮箱验证码
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
    }else {
        res.send({
            code: -1,
            msg :'提交的邮箱格式不正确?'
        })
    }
})

// 注册接口 (有验证码)
router.post('/register', async (req, res) => {
    let user_id = uuidv4() || Math.random().toString().slice(2);//随机ID
    let user_name = req.body.user_name; // 用户名
    let user_password = req.body.user_password; // 密码
    let user_email = req.body.user_email; //  邮箱 
    let user_create_time = req.body.user_create_time || getCreateTime.now()//  用户创建的时间 （'2022-09-29 00:00:00'）
    let code = req.body.code //验证码
    // 判断前端是否传值
    if(user_name == undefined || user_password == undefined || user_email == undefined || code == undefined ){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确?'
        })
        return ;
    }

    if(user_name == false || user_password == false || user_email == false || code == false ){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确?'
        })
        return ;
    }

    if(rep_email.test(user_email)) {
        // 调用注册方法
        await userModel.addUser(user_id, user_name, user_password, user_email, user_create_time, code)// 有邮箱验证码
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
    }else {
        res.send({
            code: -1,
            msg :'提交的邮箱格式不正确?'
        })
    }

    })
// 2.0 登录接口
// 参数：user_account , user_password
router.post('/login', async (req, res) => {
    let user_account = req.body.user_account; //  账号（邮箱或手机） 
    let user_password = req.body.user_password; // 密码
    // console.log({user_account, user_password});
    if(user_account == undefined || user_password == undefined){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确?'
        })
        return ;
    }

    if(user_account == false || user_password == false){
        res.send({
            code: -1,
            msg :'缺少参数，检查提交的方式是否正确?'
        })
        return ;
    }
    if(rep_phone.test(user_account) || rep_email.test(user_account)) {
        // 调用登录方法
        await userModel.login(user_account, user_password)
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
    }
    else {
        res.send({
            code: -1,
            msg :'账号格式不正确?'
        })
    }
 
})
// 3.0 删除用户账号接口
// 参数： token , code
router.post('/remove', async (req, res) => {
    let token = req.body.token
    let code = req.body.code
    let user_id = req.body.user_id
    // 请求需要进行token校验 
    let jwt = new JwtUtil(token);
    // 返回一个对象 
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        if (result.data) {
            // 调用删除用户账号方法
            await userModel.delete(user_id, code)
                .then(
                    data => {
                        res.send(data)
                    }
                )
                .catch(
                    err => {
                        res.send({ code: 500, msg: '服务器异常...', err })
                    }
                )
        }
    }
})
// 4.0 修改用户密码接口
// 参数：token user_id  new_password
router.get('/update', async (req, res) => {
    let user_id = req.query.user_id
    let new_password = req.query.new_password
    let token = req.query.token
    // 请求需要进行token校验 
    let jwt = new JwtUtil(token)
    // 返回一个对象 
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        if (result.data) {
            // 调用更改密码方法
            await userModel.update(user_id, new_password)
                .then(
                    data => {
                        res.send(data)
                    }
                )
                .catch(
                    err => {
                        res.send({ code: 500, msg: '服务器异常...', err })
                    }
                )
        }
    }
})

// 设置填写用户信息
// 参数：token user_id  new_password
router.post('/set_info', async (req, res) => {
    // let user_id = req.body.user_id
    let user_name = req.body.user_name
    let user_phone = req.body.user_phone
    let user_address = req.body.user_address
    let user_age = req.body.user_age
    let user_sex = req.body.user_sex
    let user_school = req.body.user_school || '未设置'
    let token = req.body.token
    // 请求需要进行token校验 
    let jwt = new JwtUtil(token)
    // 返回一个对象 
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        if (result.data) {
            let user_id = result.data;
            // 调用设置用户信息方法
            await userModel.set_info(user_id, user_name,user_phone,user_address,user_age,user_sex,user_school)
                .then(
                    data => {
                        res.send(data)
                    }
                )
                .catch(
                    err => {
                        res.send({ code: 500, msg: '服务器异常...', err })
                    }
                )
        }
    }
})


// 修改用户头像接口(通过filename属性定制)
const storage = multer.diskStorage({
    // 保存的路径
    destination(req, file, callback) {
        callback(null, 'public/upload/')
    },
    filename(req, file, callback) {
        // 将保存文件名设置为 字段名 + 时间戳，比如 logo-1478521468943
        let suffix = file.mimetype.split('/')[1]; //获取文件格式
        callback(null, file.fieldname + '-' + Date.now() + '.' + suffix);
    }
})
// 生成的图片放入uploads文件夹下
const upload = multer({ storage: storage })
// 5.0更换用户头像的接口
router.post('/modify', upload.single('photo'), async (req, res) => {
    // 请求需要进行token校验 
    let token = req.body.token
    let jwt = new JwtUtil(token)
    let result = jwt.verifyToken()
    // console.log('test:',req.file)
    // 接收前端的参数
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录'
        })
    } else {
        // 接收前端的文件
        let file = req.file
        // 定义存在在服务器的图片的路径（存在数据库的路径）
        let avatar = `${HOSTURL}/upload/${file.filename}`
        let user_id = result.data
        // 调用修改用户头像方法
        await userModel.modify(user_id, avatar)
            .then(
                data => {
                    res.send(data)
                }
            )
            .catch(
                err => {
                    res.send({ code: 500, msg: '服务器异常...', err })
                }
            )
    }
})
// 6.1 找回密码
router.post('/verify',async  (req, res)=> {
    let code = req.body.code //验证码
    let user_email = req.body.user_email //  邮箱 
    if(code == undefined || user_email == undefined) {
        res.send({
            code: -1,
            msg: '缺少参数，请重新输入。'
        })
    }else {
        // 调用注册方法
        await userModel.verify(user_email,code)// 有邮箱验证码
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
    }
    
})
// 6.2 找回密码
router.post('/findpwd', async (req, res) => {
    let new_password = req.body.new_password // 密码
    let user_email = req.body.user_email //  邮箱 
    // 请求需要进行token校验 
    let token = req.body.token
    let jwt = new JwtUtil(token)
    let result = jwt.verifyToken()
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    }
    else {
        // 调用注册方法
        // user_email,new_password
        let user_id = result.data;
        await userModel.findpwd(user_email,new_password,user_id)// 有邮箱验证码
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...xxx', err })
            }
        )
    }
})
// 7.0 获取指定分页用户列表
router.get('/items', async (req, res) => {
    const page_num = req.query.page_num //当前的页码
    const page_size = req.query.page_size //当前页的数量
    // 调用获取分页内容列表
    await userModel.items(page_num, page_size)
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...1', err })
            }
        )
})
// 8.0 获取用户昵称
router.post('/nickName', async (req, res) => {
    let token = req.body.token
    // 请求需要进行token校验 
    let jwt = new JwtUtil(token);
    // 返回一个对象 
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        if (result.data) {
            // 调用删除用户账号方法
            await userModel.nickName(result.data)
                .then(
                    data => {
                        res.send(data)
                    }
                )
                .catch(
                    err => {
                        res.send({ code: 500, msg: '服务器异常...', err })
                    }
                )
        }
    }
})
// 9.0 获取用户总数
router.get('/all', async (req, res) => {
    // 调用获取分页内容列表
    await userModel.all()
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
})
// 10.0 用户账号详情接口
router.get('/detail', function (req, res) {
    let token = req.query.token 
    // 请求需要进行token校验 
    let jwt = new JwtUtil(token)
    // 返回一个对象 
    let result = jwt.verifyToken()
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        if (result.data) {
            //用户身份
            let user_id = result.data
             // 调用获取题目详情方法
            userModel.detail(user_id)
            .then(
                data => {
                    res.send(data)
                }
            )
            .catch(
                err => {
                    res.send({ code: 500, msg: '服务器异常...', err })
                }
            )
        }
    }
})

// 8.0 删除旧用户头像
router.post('/deleteImg', async (req, res) => {
    let user_avatar = req.body.user_avatar;
   
    // 调用删除旧用户头像
    await userModel.deleteImg(user_avatar)
        .then(
            data => {
                res.send(data)
            }
        )
        .catch(
            err => {
                res.send({ code: 500, msg: '服务器异常...', err })
            }
        )
})

// 路由挂在模块系统下
module.exports = router;
